xplly'Blog

一、SLF4J

Java简易日志门面（Simple Logging Facade for Java，缩写SLF4J），是一套包装Logging 框架的界面程式，以外观模式实现。可以在软件部署的时候决定要使用的 Logging 框架，目前主要支援的有Java Logging API、Log4j及logback等框架。以MIT 授权方式发布。

SLF4J其实只是一个门面服务而已，他并不是真正的日志框架，真正的日志的输出相关的实现还是要依赖Log4j、logback等日志框架的。类似的还有JCL（JCL不推荐，缺点明显）官网：https://www.slf4j.org/

原理

SLF4J通过LoggerFactory加载日志具体的实现对象。
LoggerFactory在初始化的过程中，会通过performInitialization()方法绑定具体的日志实现。
在绑定具体实现的时候，通过类加载器，加载org/slf4j/impl/StaticLoggerBinder.class
所以，只要是一个日志实现框架，在org.slf4j.impl包中提供一个自己的StaticLoggerBinder类，在其中提供具体日志实现的LoggerFactory就可以被SLF4J所加载
slf4j⽇志级别有五种：ERROR、WARN、INFO、DEBUG、TRACE，级别从⾼到底

1.1 简单使用

添加依赖

xml

<dependencies>
	<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-api</artifactId>
		<version>1.7.26</version>
	</dependency>
</dependencies>
<!--slf4j 自带的简单日志实现 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.27</version> 
</dependency>

使用demo

java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Demo {
	private static final Logger LOGGER = LoggerFactory.getLogger(Demo.class);
    public static void main(String[] args) {
        LOGGER.info("这是info日志信息. 代码之前进行打印信息。");
        System.out.println("测试代码");
        LOGGER.error("这是error日志信息. 代码之后进行打印信息。");
    }
}

1.2 与其他日志框架整合

添加对应的日志框架的依赖

1.3 桥接新的日志框架

桥接解决的是项目中日志的遗留问题，当系统中存在之前的日志API，可以通过桥接转换到slf4j的实现

先去除之前老的日志框架的依赖
添加SLF4J提供的桥接组件
为项目添加SLF4J的具体实现

xml

<!-- log4j-->
<dependency> 
    <groupId>org.slf4j</groupId> 
    <artifactId>log4j-over-slf4j</artifactId> 
    <version>1.7.27</version>
</dependency>
<!-- jul -->
<dependency>
    <groupId>org.slf4j</groupId> 
    <artifactId>jul-to-slf4j</artifactId> 
    <version>1.7.27</version>
</dependency>
<!--jcl --> 
<dependency> 
    <groupId>org.slf4j</groupId> 
    <artifactId>jcl-over-slf4j</artifactId> 
    <version>1.7.27</version> 
</dependency>
<!--log4j2 - slf-->
<dependency>
	<groupId>org.apache.logging.log4j</groupId>
	<artifactId>log4j-to-slf4j</artifactId>
	<version>2.13.0</version>
</dependency>

jcl-over-slf4j.jar和 slf4j-jcl.jar不能同时部署。前一个jar文件将导致JCL将日志系统的选择委托给SLF4J，后一个jar文件将导致SLF4J将日志系统的选择委托给JCL，从而导致无限循环。
log4j-over-slf4j.jar和slf4j-log4j12.jar不能同时出现
jul-to-slf4j.jar和slf4j-jdk14.jar不能同时出现
所有的桥接都只对Logger日志记录器对象有效，如果程序中调用了内部的配置类或者是Appender,Filter等对象，将无法产生效果。

二、JUL

JUL全称Java util Logging是java原生的日志框架，使用时不需要另外引用第三方类库

架构角色：

Loggers：被称为记录器，应用程序通过获取Logger对象，调用其API来来发布日志信息。Logger通常时应用程序访问日志系统的入口程序。

Appenders：也被称为Handlers，每个Logger都会关联一组Handlers，Logger会将日志交给关联Handlers处理，由Handlers负责将日志做记录。Handlers在此是一个抽象，其具体的实现决定了日志记录的位置可以是控制台、文件、网络上的其他日志服务或操作系统日志等。

Layouts：也被称为Formatters，它负责对日志事件中的数据进行转换和格式化。Layouts决定了数据在一条日志记录中的最终形式。

Level：每条日志消息都有一个关联的日志级别。该级别粗略指导了日志消息的重要性和紧迫，可以将Level和Loggers，Appenders做关联以便于我们过滤消息。

Filters：过滤器，根据需要定制哪些信息会被记录，哪些信息会被放过。

用户使用Logger来进行日志记录，Logger持有若干个Handler，日志的输出操作是由Handler完成的。在Handler在输出日志前，会经过Filter的过滤，判断哪些日志级别过滤放行哪些拦截，Handler会将日志内容输出到指定位置（日志文件、控制台等）。Handler在输出日志时会使用Layout，将输出内容进行排版。

2.1 日志配置

java

// 日志记录器对象父子关系 
Logger logger1 = Logger.getLogger("com.itheima.log"); 
Logger logger2 = Logger.getLogger("com.itheima");
System.out.println(logger1.getParent() == logger2); 
// 所有日志记录器对象的顶级父元素 class为java.util.logging.LogManager$RootLogger name为"" 
System.out.println("logger2 parent:" + logger2.getParent() + "，name：" + logger2.getParent().getName());

// 一、自定义日志级别 // 默认只实现info级别
// a.关闭系统默认配置 
logger2.setUseParentHandlers(false); 
// b.创建handler对象 
ConsoleHandler consoleHandler = new ConsoleHandler(); 
// c.创建formatter对象 
SimpleFormatter simpleFormatter = new SimpleFormatter(); 
// d.进行关联 
consoleHandler.setFormatter(simpleFormatter); 
logger2.addHandler(consoleHandler); 
// e.设置日志级别 
logger2.setLevel(Level.ALL);
consoleHandler.setLevel(Level.ALL); 

// 二、输出到日志文件 
FileHandler fileHandler = new FileHandler("d:/logs/jul.log");
fileHandler.setFormatter(simpleFormatter);
logger.addHandler(fileHandler);

// 测试日志记录器对象父子关系 
logger1.severe("severe"); 
logger1.warning("warning"); 
logger1.info("info"); 
logger1.config("config"); 
logger1.fine("fine"); 
logger1.finer("finer"); 
logger1.finest("finest");

日志级别

java.util.logging.Level中定义了日志的级别： SEVERE（最高值）、WARNING、INFO （默认级别）、CONFIG 、FINE 、FINER、FINEST（最低值）

还有两个特殊的级别： OFF，可用来关闭日志记录；ALL，启用所有消息的日志记录。

父子关系

父子关系通过树状结构存储，JUL在初始化时会创建一个顶层RootLogger作为所有Logger父Logger，存储上作为树状结构的根节点。并父子关系通过包路径来关联。

2.2 配置文件

读取配置文件

java

public void testProperties() throws Exception {
    // 读取自定义配置文件 
    InputStream in = JULTest.class.getClassLoader().getResourceAsStream("logging.properties");
    // 获取日志管理器对象
    LogManager logManager = LogManager.getLogManager(); 
    // 通过日志管理器加载配置文件
    logManager.readConfiguration(in);
    Logger logger = Logger.getLogger("com.itheima.log.JULTest");
    logger.severe("severe"); 
    logger.warning("warning");
    logger.info("info"); 
    logger.config("config"); 
    logger.fine("fine");
    logger.finer("finer"); 
    logger.finest("finest");
}

配置文件

默认配置文件路径$JAVAHOME\jre\lib\logging.properties

properties

## RootLogger使用的处理器（获取时设置）
handlers= java.util.logging.ConsoleHandler 
# RootLogger日志等级 


<NolebasePageProperties />




.level= INFO

## 自定义Logger 
com.itheima.handlers= java.util.logging.FileHandler 
# 自定义Logger日志等级 
com.itheima.level= INFO 
# 忽略父日志设置 
com.itheima.useParentHandlers=false 

## 控制台处理器 
# 输出日志级别 
java.util.logging.ConsoleHandler.level = INFO 
# 输出日志格式 
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

## 文件处理器 
# 输出日志级别
java.util.logging.FileHandler.level=INFO
# 输出日志格式 
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter 
# 输出日志文件路径
java.util.logging.FileHandler.pattern = /java%u.log 
# 输出日志文件限制大小（50000字节）
java.util.logging.FileHandler.limit = 50000 
# 输出日志文件限制个数
java.util.logging.FileHandler.count = 10
# 输出日志文件 是否是追加 
java.util.logging.FileHandler.append=true

原理分析

初始化LogManager
1. LogManager加载logging.properties配置
2. 添加Logger到LogManager
从单例LogManager获取Logger
设置级别Level，并指定日志记录LogRecord
Filter提供了日志级别之外更细粒度的控制
Handler是用来处理日志输出位置
Formatter是用来格式化LogRecord的

三、Log4J

Log4j是Apache下的一款开源的日志框架，通过在项目中使用 Log4J，我们可以控制日志信息输出到控制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式，通过定义日志的输出级别，可以更灵活的控制日志的输出过程。方便项目的调试。

官方网站

3.1 日志级别介绍

默认会寻找source folder下的log4j.xml，没有寻找找log4j.properties

* 每个Logger都被了一个日志级别（log level），用来控制日志信息的输出。日志级别从高到低分 为： 
fatal 指出每个严重的错误事件将会导致应用程序的退出。 
error 指出虽然发生错误事件，但仍然不影响系统的继续运行。
warn 表明会出现潜在的错误情形。 
info 一般和在粗粒度级别上，强调应用程序的运行全程。 
debug 一般用于细粒度级别上，对调试应用程序非常有帮助。
trace 是程序追踪，可以用于输出程序运行中的变量，显示执行的流程。 

* 还有两个特殊的级别：
OFF，可用来关闭日志记录。
ALL，启用所有消息的日志记录。

一般只使用4个级别，优先级从高到低为 ERROR > WARN > INFO > DEBUG

3.2 使用Demo

添加依赖

xml

<dependency> 
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
<dependency>
	<groupId>log4j</groupId>
	<artifactId>apache-log4j-extras</artifactId>
	<version>1.2.17</version>
</dependency>

日志记录

java

// 初始化系统配置，不需要配置文件 
BasicConfigurator.configure(); 
// 创建日志记录器对象
Logger logger = Logger.getLogger(Log4jTest.class);
// 日志记录输出 
logger.info("hello log4j"); 

// 日志级别 
logger.fatal("fatal"); // 严重错误，一般会造成系统崩溃和终止运行 
logger.error("error"); // 错误信息，但不会影响系统运行 
logger.warn("warn"); // 警告信息，可能会发生问题 
logger.info("info"); // 程序运行信息，数据库的连接、网络、IO操作等 
logger.debug("debug"); // 调试信息，一般在开发阶段使用，记录程序的变量、参 数等 
logger.trace("trace"); // 追踪信息，记录程序的所有流程信息

3.3 组件介绍

Loggers

日志记录器，负责收集处理日志记录，实例的命名就是类“XX”的full quailied name（类的全限定名），Logger的名字大小写敏感，其命名有继承机制：例如：name为org.apache.commons的logger会继承name为org.apache的logger。

Log4J中有一个特殊的logger叫做“root”，他是所有logger的根，也就意味着其他所有的logger都会直接或者间接地继承自root。root logger可以用Logger.getRootLogger()方法获取。

Appenders

Log4j 常用的输出目的地有

输出端类型	作用
ConsoleAppender	将日志输出到控制台
FileAppender	将日志输出到文件
DailyRollingFileAppender	将日志输出到一个日志文件，并且每天输出到一个新的文件
RollingFileAppender	将日志输出到一个日志文件，并且指定文件的尺寸，当文件大小达到十，自动改名并产生新的文件
JDBCAppender	将日志信息保存到数据库中

Layouts

布局器 Layouts用于控制日志输出内容的格式，可以使用各种需要的格式输出日志

格式化器类型	作用
HTMLLayout	格式化日志输出为HTML表格形式
SimpleLayout	简单的日志输出格式化，打印的日志格式为（info - message）
PatternLayout	最强大的格式化期，可以根据自定义格式输出日志，如果没有指定转换格式，就是用默认的转换格式

3.4 拓展

Layout格式

properties

*log4j 采用类似 C 语言的 printf 函数的打印格式格式化日志信息，具体的占位符及其含义如下：
	%m 输出代码中指定的日志信息 
	%p 输出优先级，及 DEBUG、INFO 等
	%n 换行符（Windows平台的换行符为 "\n"，Unix 平台为 "\n"） 
	%r 输出自应用启动到输出该 log 信息耗费的毫秒数 
	%c 输出打印语句所属的类的全名 
	%t 输出产生该日志的线程全名 
	%d 输出服务器当前时间，默认为 ISO8601，也可以指定格式，如：%d{yyyy年MM月dd日 HH:mm:ss}
	%l 输出日志时间发生的位置，包括类名、线程、及在代码中的行数。如： Test.main(Test.java:10)
	%F 输出日志消息产生时所在的文件名称
	%L 输出代码中的行号 
	%% 输出一个 "%" 字符 

*可以在 % 与字符之间加上修饰符来控制最小宽度、最大宽度和文本的对其方式。如： 
	%5c 输出category名称，最小宽度是5，category<5，默认的情况下右对齐 
	%-5c 输出category名称，最小宽度是5，category<5，"-"号指定左对齐,会有空格 
	%.5c 输出category名称，最大宽度是5，category>5，就会将左边多出的字符截掉，<5不 会有空格 
	%20.30c category名称<20补空格，并且右对齐，>30字符，就从左边交远销出的字符截掉

Appender的输出配置

properties方式

properties

#指定日志的输出级别与输出端 
log4j.rootLogger=INFO,Console

# 自定义logger输出
log4j.logger.com.itheima = info,file 
log4j.logger.org.apache = error

# 控制台输出配置 
log4j.appender.Console=org.apache.log4j.ConsoleAppender 
log4j.appender.Console.layout=org.apache.log4j.PatternLayout 
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n 

# 文件输出配置 
log4j.appender.A = org.apache.log4j.DailyRollingFileAppender 
#指定日志的输出路径 
log4j.appender.A.File = D:/log.txt 
log4j.appender.A.Append = true 

#使用自定义日志格式化器 
log4j.appender.A.layout = org.apache.log4j.PatternLayout 
#指定日志的输出格式 
log4j.appender.A.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [%t:%r] - [%p] %m%n 
#指定日志的文件编码 
log4j.appender.A.encoding=UTF-8

#mysql 
log4j.appender.logDB=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.logDB.layout=org.apache.log4j.PatternLayout
log4j.appender.logDB.Driver=com.mysql.jdbc.Driver 
log4j.appender.logDB.URL=jdbc:mysql://localhost:3306/test 
log4j.appender.logDB.User=root 
log4j.appender.logDB.Password=root 
log4j.appender.logDB.Sql=INSERT INTO log(project_name,create_date,level,category,file_name,thread_name,line,all_categ ory,message) values('itcast','%d{yyyy-MM-dd HH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')

xml方式

xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration debug="true" xmlns:log4j='http://jakarta.apache.org/log4j/'>
	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
         <param name="Target" value="System.out"/>
         <layout class="org.apache.log4j.PatternLayout">
         	<param name="ConversionPattern"value=""/>
 		</layout>
 		<filter class="org.apache.log4j.varia.LevelRangeFilter">
			<param name="LevelMin" value="DEBUG"/>
			<param name="LevelMax" value="DEBUG"/>
		</filter>
	</appender>
    <appender name="DAILYROLLINGFILE" class="org.apache.log4j.DailyRollingFileAppender">
		<param name="File" value="log4j.log"/>
		<param name="DatePattern" value="yyyy-MM-dd"/>
		<param name="Append" value="true"/>
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss a} [Thread: %t][ Class:%c Method: %l ]%n%p:%m%n"/>
		</layout>
	</appender>
    
	<root>
		<appender-ref ref="CONSOLE"/>
		<appender-ref ref="DAILYROLLINGFILE"/>
	</root>
</log4j:configuration>

四、log4j2

Apache Log4j 2是对Log4j的升级版，Log4j2也是日志门面，参考了logback的一些优秀的设计，并且修复了一些问题，因此带来了一些重大的提升，主要有：

异常处理，在logback中，Appender中的异常不会被应用感知到，但是在log4j2中，提供了一些异常处理机制。

性能提升， log4j2相较于log4j 和logback都具有很明显的性能提升。

自动重载配置，参考了logback的设计，当然会提供自动刷新参数配置，最实用的就是我们在生产上可以动态的修改日志的级别而不需要重启应用。

无垃圾机制，log4j2在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集导致的jvm gc。

官网

日志级别：ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF

log4j2默认加载classpath下的 log4j2.xml 文件中的配置。

4.1 使用Demo

依赖

xml

<!-- Log4j2 门面API--> 
<dependency> 
    <groupId>org.apache.logging.log4j</groupId> 
    <artifactId>log4j-api</artifactId>
    <version>2.11.1</version> 
</dependency>
<!-- Log4j2 日志实现 --> 
<dependency> 
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.11.1</version>
</dependency>

日志记录

java

// 定义日志记录器对象 
public static final Logger LOGGER = LogManager.getLogger(Log4j2Test.class);
@Test 
public void testQuick() throws Exception { 
    LOGGER.fatal("fatal");
    LOGGER.error("error");
    LOGGER.warn("warn");
    LOGGER.info("info"); 
    LOGGER.debug("debug");
    LOGGER.trace("trace");
}

4.2 slf4j集成log4j2

依赖

xml

<!-- Log4j2 门面API-->
<dependency> 
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.11.1</version> 
</dependency> 
<!-- Log4j2 日志实现 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId> 
    <artifactId>log4j-core</artifactId>
    <version>2.11.1</version>
</dependency> 
<!--使用slf4j作为日志的门面,使用log4j2来记录日志 --> 
<dependency> 
    <groupId>org.slf4j</groupId> 
    <artifactId>slf4j-api</artifactId> 
    <version>1.7.25</version> 
</dependency> 
<!--为slf4j绑定日志实现 log4j2的适配器 --> 
<dependency> 
    <groupId>org.apache.logging.log4j</groupId> 
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.10.0</version>
</dependency>

配置

xml

<?xml version="1.0" encoding="UTF-8"?> 
<Configuration status="warn" monitorInterval="5"> 
    
    <properties> 
        <property name="LOG_HOME">D:/logs</property>
    </properties>
    
    <Appenders> 
        <Console name="Console" target="SYSTEM_OUT"> 
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L - -- %m%n" />
        </Console> 
        <!--append="false" :根据其下⽇志策略,每次清空⽂件重新输⼊⽇志,可⽤于测试-->
        <File name="file" fileName="${LOG_HOME}/myfile.log" append="false"> 
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
        </File>
        <RandomAccessFile name="accessFile" fileName="${LOG_HOME}/myAcclog.log"> 
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" /> 
        </RandomAccessFile> 
        <RollingFile name="rollingFile" fileName="${LOG_HOME}/myrollog.log" filePattern="D:/logs/$${date:yyyy-MM-dd}/myrollog-%d{yyyy- MM-dd-HH-mm}-%i.log">
            <!--level="info" :⽇志级别,onMatch="ACCEPT" :级别在info之上则接受,onMismatch="DENY" :级别在info之下则拒绝-->
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" /> 
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %msg%n" /> 
            <!-- Policies :⽇志滚动策略-->
            <Policies> 
                <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同⼀⽂件夹下7个⽂件，这⾥设置了20 -->
                <DefaultRolloverStrategy max="20"/>
                <OnStartupTriggeringPolicy />
                <!-- SizeBasedTriggeringPolicy :⽂件⼤⼩滚动策略-->
                <SizeBasedTriggeringPolicy size="10 MB" />
                <!-- TimeBasedTriggeringPolicy :时间滚动策略,默认0点产⽣新的⽂件,interval="6" : ⾃定义⽂件滚动时间间隔,每隔6⼩时产⽣新⽂件,modulate="true" : 产⽣⽂件是否以0点偏移时间,即6点,12点,18点,0点-->
                <TimeBasedTriggeringPolicy /> 
            </Policies> 
            <DefaultRolloverStrategy max="30" />
        </RollingFile> 
    </Appenders> 
    
    <!--然后定义logger，只有定义了logger并引⼊的appender，appender才会⽣效-->
    <Loggers>
        <!--过滤掉spring和mybatis的⼀些⽆⽤的DEBUG信息-->
        <!--Logger节点⽤来单独指定⽇志的形式，name为包路径,⽐如要为org.springframework包下所有⽇志指定为INFO级别等。 -->
        <logger name="org.springframework" level="INFO"></logger>
        <logger name="org.mybatis" level="INFO"></logger>
        
        <!--AsyncLogger :异步⽇志,LOG4J有三种⽇志模式,全异步⽇志,混合模式,同步⽇志,性能从⾼到底,线程越多效率越⾼,也可以避免⽇志卡死线程情况发⽣--
		<!--additivity="false" : additivity设置事件是否在root logger输出，为了避免重复输出，可以在Logger 标签下设置additivity为”false”-->		<AsyncLogger name="AsyncLogger" level="trace" includeLocation="true" additivity="true">
        	<appender-ref ref="Console"/>
		</AsyncLogger>
		<logger name="Kafka" additivity="false" level="debug">
			<appender-ref ref="Kafka"/>
			<appender-ref ref="Console"/>
		</logger>
        
		<!-- Root节点⽤来指定项⽬的根⽇志，如果没有单独指定Logger，那么就会默认使⽤该Root⽇志输出 -->
        <Root level="trace"> 
            <AppenderRef ref="Console" /> 
        </Root> 
    </Loggers>
</Configuration>

4.3 日志处理器

详细

处理器名称	处理器作用
FileAppender	输出到本地⽂件
KafkaAppender	输出到kafka队列
FlumeAppender	将⼏个不同源的⽇志汇集、集中到⼀处
JMSQueueAppender，JMSTopicAppender	与JMS相关的⽇志输出
RewriteAppender	对⽇志事件进⾏掩码或注⼊信息
RollingFileAppender	对⽇志⽂件进⾏封存（详细）
RoutingAppender	在输出地之间进⾏筛选路由
SMTPAppender	将LogEvent发送到指定邮件列表
SocketAppender	将LogEvent以普通格式发送到远程主机
SyslogAppender	将LogEvent以RFC 5424格式发送到远程主机
AsynchAppender	将⼀个LogEvent异步地写⼊多个不同输出地
ConsoleAppender	将LogEvent输出到命令⾏
FailoverAppender	维护⼀个队列，系统将尝试向队列中的Appender依次输出LogEvent，直到有⼀个成功为⽌

4.4 日志格式化

详情

4.5 异步日志

Log4j2提供了两种实现日志的方式，一个是通过AsyncAppender，一个是通过AsyncLogger，分别对应前面我们说的Appender组件和Logger组件。

添加依赖

xml

<!--异步日志依赖--> 
<dependency> 
    <groupId>com.lmax</groupId> 
    <artifactId>disruptor</artifactId> 
    <version>3.3.4</version>
</dependency>

AsyncAppender方式

xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn"> 
    
    <properties> 
        <property name="LOG_HOME">D:/logs</property> 
    </properties>
    
    <Appenders>
        <File name="file" fileName="${LOG_HOME}/myfile.log"> 
            <PatternLayout> 
                <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
            </PatternLayout>
        </File>
        <Async name="Async">
            <AppenderRef ref="file"/> 
        </Async> 
    </Appenders>
    <Loggers>
        <Root level="error">
            <AppenderRef ref="Async"/>
        </Root>
    </Loggers> 
</Configuration>

AsyncLogger方式

AsyncLogger是官方推荐的异步方式。它可以使得调用Logger.log返回的更快。有两种选择：全局异步和混合异步。

全局异步就是，所有的日志都异步的记录，在配置文件上不用做任何改动，只需要添加一个log4j2.component.properties 配置；

properties

Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerCon textSelector

混合异步就是，你可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加灵活。

xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    
    <properties> 
        <property name="LOG_HOME">D:/logs</property> 
    </properties> 
    
    <Appenders>
        <File name="file" fileName="${LOG_HOME}/myfile.log"> 
            <PatternLayout>
                <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
            </PatternLayout>
        </File>
        <Async name="Async">
            <AppenderRef ref="file"/> 
        </Async> 
    </Appenders>
    <Loggers>
        <AsyncLogger name="com.itheima" level="trace" includeLocation="false" additivity="false"> 
            <AppenderRef ref="file"/> 
        </AsyncLogger>
        <Root level="info" includeLocation="true">
            <AppenderRef ref="file"/>
        </Root>
    </Loggers>
</Configuration>

使用异步日志需要注意的问题：

如果使用异步日志，AsyncAppender、AsyncLogger和全局日志，不要同时出现。性能会和AsyncAppender一致，降至最低。
设置includeLocation=false ，打印位置信息会急剧降低异步日志的性能，比同步日志还要慢。

4.6 无垃圾记录

从版本2.6开始，默认情况下Log4j以“无垃圾”模式运行，其中重用对象和缓冲区，并且尽可能不分配临时对象。还有一个“低垃圾”模式，它不是完全无垃圾，但不使用ThreadLocal字段。

Log4j 2.6中的无垃圾日志记录部分通过重用ThreadLocal字段中的对象来实现，部分通过在将文本转换为字节时重用缓冲区来实现

有两个单独的系统属性可用于手动控制Log4j用于避免创建临时对象的机制：

log4j2.enableThreadlocals - 如果“true”（非Web应用程序的默认值）对象存储在ThreadLocal字段中并重新使用，否则将为每个日志事件创建新对象。

log4j2.enableDirectEncoders - 如果将“true”（默认）日志事件转换为文本，则将此文本转换为字节而不创建临时对象。

注意：由于共享缓冲区上的同步，在此模式下多线程应用程序的同步日志记录性能可能更差。如果您的应用程序是多线程的并且日志记录性能很重要，请考虑使用异步记录器。

五、Logback

Logback是由log4j创始人设计的另一个开源日志组件，性能比log4j要好。

官方网站

Logback主要分为三个模块：

logback-core：其它两个模块的基础模块

logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API

logback-access：访问模块与Servlet容器集成提供通过Http来访问日志的功能

⽇志打印级别 ALL > TRACE > FATAL > DEBUG > INFO > WARN > ERROR > OFF

5.1 使用demo

依赖

xml

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId> 
    <version>1.2.3</version> 
</dependency>

日志记录

java

//定义日志对象 
public final static Logger LOGGER = LoggerFactory.getLogger(LogBackTest.class);
@Test 
public void testSlf4j(){
    //打印日志信息
    LOGGER.error("error");
    LOGGER.warn("warn");
    LOGGER.info("info");
    LOGGER.debug("debug");
    LOGGER.trace("trace");
}

配置读取说明

以logback.xml命名在spring的配置文件加载前执行。以logback-spring.xml在spring配置文件加载后执行。后者可以使用spring中的配置

logback会依次读取以下类型配置文件：

logback.groovy

logback-test.xml

logback.xml 如果均不存在会采用默认配置

logback组件之间的关系
1. Logger:日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志对象，也可以定义日志类型、级别。
Appender:用于指定日志输出的目的地，目的地可以是控制台、文件、数据库等等。
Layout:负责把事件转换成字符串，格式化的日志信息的输出。在logback中Layout对象被封装在encoder中。

配置文件

xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!--
        配置集中管理属性
        我们可以直接改属性的 value 值
        格式：${name}
    -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n"></property>
    <!--
    日志输出格式：
        %-5level
        %d{yyyy-MM-dd HH:mm:ss.SSS}日期
        %c类的完整名称
        %M为method
        %L为行号
        %thread线程名称
        %m或者%msg为信息
        %n换行
      -->
    <!--定义日志文件保存路径属性-->
    <property name="log_dir" value="/logs"></property>


    <!--Appender: 设置日志信息的去向,常用的有以下几个 
		ch.qos.logback.core.ConsoleAppender (控制台)
		ch.qos.logback.core.rolling.RollingFileAppender (文件大小到达指定尺 寸的时候产生一个新文件) 
		ch.qos.logback.core.FileAppender (文件)
	-->
    <!--控制台日志输出的 appender-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!--控制输出流对象 默认 System.out 改为 System.err-->
        <target>System.err</target>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    
	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
		<encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <!--<charset>UTF-8</charset>-->
            <!--<pattern>${logPattern}</pattern>-->
            <!--<layout class="com.itheima.logback.MySampleLayout" />-->
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>%relative%thread%mdc%level%logger%msg</pattern>
            </layout>
            <!--<layout class="ch.qos.logback.classic.log4j.XMLLayout">-->
            <!--<locationInfo>false</locationInfo>-->
            <!--</layout>-->
		</encoder>
	</appender>

    <!--日志文件输出的 appender-->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!--日志文件保存路径-->
        <file>${log_dir}/logback.log</file>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!--html 格式日志文件输出 appender-->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!--日志文件保存路径-->
        <file>${log_dir}/logback.html</file>
        <!--html 消息格式配置-->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>%-5level%d{yyyy-MM-dd HH:mm:ss.SSS}%c%M%L%thread%m</pattern>
            </layout>
        </encoder>
    </appender>


    <!--日志拆分和归档压缩的 appender 对象-->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--日志文件保存路径-->
        <file>${log_dir}/roll_logback.log</file>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
        
        <!--指定拆分规则 大小-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--按照时间和压缩格式声明拆分的文件名-->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <!--按照文件大小拆分-->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <!--指定拆分规则 时间-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
			<fileNamePattern>./logback.log.%d{yyyy-MM-dd}.zip</fileNamePattern>
			<!-- 最⼤保存时间 -->
			<maxHistory>2</maxHistory>
		</rollingPolicy>
        
        <!--日志级别过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--日志过滤规则-->
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    
    <!-- DB -->
	<appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
		<connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
			<driverClass>com.mysql.jdbc.Driver</driverClass>
			<url>jdbc:mysql://172.17.0.203:3306/log?useSSL=false</url>
			<user>root</user>
			<password>root</password>
		</connectionSource>
	</appender>
    
    

    <!--异步日志-->
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
		<!-- 不丢失⽇志.默认的,如果队列的80%已满,则会丢弃TRACT、DEBUG、INFO级别的⽇志 -->
		<discardingThreshold>0</discardingThreshold>
		<!-- 更改默认的队列的深度,该值会影响性能.默认值为256 -->
		<queueSize>3</queueSize>
        <!--指定某个具体的 appender-->
        <appender-ref ref="rollFile"/>
    </appender>
    
    <!-- This example configuration is probably most unreliable under failure conditions but wont block your application at all -->
	<appender name="kafka" class="com.github.danielwegener.logback.kafka.KafkaAppender">
		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
			<pattern>%msg%n</pattern>
		</encoder>
		<topic>demo</topic>
		<!-- we don't care how the log messages will be partitioned -->
		<keyingStrategy class="com.github.danielwegener.logback.kafka.keying.NoKeyKeyingStrategy"/>
		<!-- use async delivery. the application threads are not blocked by logging -->
		<deliveryStrategy class="com.github.danielwegener.logback.kafka.delivery.AsynchronousDeliveryStrategy"/>
		<!-- each <producerConfig> translates to regular kafka-client config(format: key=value) -->
		<!-- producer configs are documented here: https://kafka.apache.org/documentation.html#newproducerconfigs -->
		<!-- bootstrap.servers is the only mandatory producerConfig -->
		<producerConfig>bootstrap.servers=39.98.133.153:9103</producerConfig>
		<!-- don't wait for a broker to ack the reception of a batch. -->
		<producerConfig>acks=0</producerConfig>
		<!-- wait up to 1000ms and collect log messages before sending them as a batch -->
		<producerConfig>linger.ms=1000</producerConfig>
		<!-- even if the producer buffer runs full, do not block the application but start to drop messages -->
		<producerConfig>max.block.ms=0</producerConfig>
		<!-- define a client-id that you use to identify yourself against the kafka broker -->
		<producerConfig>client.id=${HOSTNAME}-${CONTEXT_NAME}-logbackrelaxed</producerConfig>
		<!-- there is no fallback <appender-ref>. If this appender cannot deliver, it will drop its messages. -->
    </appender>
    
	<logger name="kafka">
		<appender-ref ref="kafka"/>
	</logger>

    <!--
	也是<logger>元素，但是它是根logger。默认debug 
	level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF， <root>可以包含零个或多个	<appender-ref>元素，标识这个appender将会添加到这个 logger。
 -->
    <!--root logger 配置-->
    <root level="ALL">
        <appender-ref ref="console"/>
        <appender-ref ref="async"/>
    </root>

        <!--
用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。 <loger>仅有一个name属性，一个可选的level和一个可选的addtivity属性 
name:用来指定受此logger约束的某一个包或者具体的某一个类。 
level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF， 如果未设置此属性，那么当前logger将会继承上级的级别。 
additivity: 是否向上级loger传递打印信息。默认是true。 <logger>可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个 logger--> 
    <!--自定义 looger 对象
        additivity="false" 自定义 logger 对象是否继承 rootLogger
     -->
    <logger name="com.itheima" level="info" additivity="false">
        <appender-ref ref="console"/>
    </logger>
</configuration>

官方提供的log4j.properties转换成logback.xml https://logback.qos.ch/translator/

使用Spring配置

1.配置中配置 logging.path 和logging.file 配置中通过 $L O G_{P} A T H 和$ {LOG_FILE}获取

2.通过springProperty标签配置 springProfile 可配置环境

xml

<springProperty scope="context" name="log.path" source="logging.path" defaultValue="logdir"/>

name：属性名称后续可使用${name}获取该项的值 source： spring配置的配置项 degaultValue：默认值

5.2 logback-access的使用

logback-access模块与Servlet容器（如Tomcat和Jetty）集成，以提供HTTP访问日志功能。我们可以使用logback-access模块来替换tomcat的访问日志。

将logback-access.jar与logback-core.jar复制到$TOMCAT_HOME/lib/目录下

修改$TOMCAT_HOME/conf/server.xml中的Host元素中添加：

xml

<Valve className="ch.qos.logback.access.tomcat.LogbackValve" />

logback默认会在$TOMCAT_HOME/conf下查找文件 logback-access.xml

xml

<?xml version="1.0" encoding="UTF-8"?> 
<configuration> 
    <!-- always a good activate OnConsoleStatusListener --> 
    <statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener"/>
    <property name="LOG_DIR" value="${catalina.base}/logs"/> 
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> 
        <file>${LOG_DIR}/access.log</file> 
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"> 
            <fileNamePattern>access.%d{yyyy-MM-dd}.log.zip</fileNamePattern>
        </rollingPolicy>
        <encoder> 
            <!-- 访问日志的格式 --> 
            <pattern>combined</pattern> 
        </encoder> 
    </appender> 
    <appender-ref ref="FILE"/> 
</configuration>

官方配置

六、SpringBoot日志使用

springboot默认就是使用SLF4J作为日志门面，logback作为日志实现来记录日志。

6.1 使用Demo

依赖

xml

<dependency> 
    <artifactId>spring-boot-starter-logging</artifactId> 
    <groupId>org.springframework.boot</groupId> 
</dependency>

记录日志

java

@SpringBootTest 
class SpringbootLogApplicationTests { 
    //记录器 
    public static final Logger LOGGER = LoggerFactory.getLogger(SpringbootLogApplicationTests.class); 
    
    @Test public void contextLoads() {
        // 打印日志信息
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); // 默认日志级别
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }
}

配置

properties

logging.level.com.itheima=trace
# 在控制台输出的日志的格式 同logback 
logging.pattern.console=%d{yyyy-MM-dd} [%thread] [%-5level] %logger{50} - %msg%n 

# 指定文件中日志输出的格式
logging.file=D:/logs/springboot.log logging.pattern.file=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n

6.2 指定配置文件

给类路径下放上每个日志框架自己的配置文件；SpringBoot就不使用默认配置的了

日志框架	配置文件
Logback	logback-spring.xml , logback.xml
Log4j2	log4j2-spring.xml ， log4j2.xml
JUL	logging.properties

logback.xml：直接就被日志框架识别了

6.3 使用SpringBoot解析日志配置

logback-spring.xml：由SpringBoot解析日志配置

xml

<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"> 
    <springProfile name="dev"> 
        <pattern>${pattern}</pattern>
    </springProfile> 
    <springProfile name="pro"> 
        <pattern>%d{yyyyMMdd:HH:mm:ss.SSS} [%thread] %-5level %msg%n</pattern> 
    </springProfile>
</encoder>

properties

# application.properties
spring.profiles.active=dev

6.4 将日志切换为log4j2

xml

<dependency> 
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId> 
    <exclusions>
        <!--排除logback--> 
        <exclusion>
            <artifactId>spring-boot-starter-logging</artifactId> 
            <groupId>org.springframework.boot</groupId> 
        </exclusion>
    </exclusions>
</dependency> 
<!-- 添加log4j2 --> 
<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-log4j2</artifactId> 
</dependency>

七、日志中间件

⽇志的⽣命周期⼀般分为采集，传输，存储和分析四个环节，每个步骤有可⽤的中间件和⼯具。

选⽤中间件时所关注的⻆度：性能、可靠性、插件⽀持程度、配置复杂度

名称	优势	劣势	常用
Logstash	插件多，资料充⾜，配置简单	性能⼀般，不⽀持缓存	采集，传输
Filebeat	可靠，性能好，多种对接	存在注册表过⼤问题	采集
Fluentd	基于Ruby，插件多，易于编写和维护	灵活性相对差，性能⼀般	采集
Logtail	资源占⽤少	尽做收集，类型解析较弱	采集
Logagent	轻量快速，⽀持缓存	灵活性差	采集，传输
rsyslog	速度快，轻量化，规则灵活	配置繁杂，⽂档差，版本差异	采集
Syslog-ng	性能好，⽂档相对⻬全	开源版本功能有限	采集
Kafka	可靠，稳定，⾼性能	容易重复消费	传输
Flume	可靠，容错性⾼，易管理，实时	配置繁琐	传输
ElasticSearch	分布式部署，⾃动故障转移	个⼈开发，还不够⾃动	存储
HDFS	⾼容错，⼤数据存储	延迟⾼，不适于⼩⽂件	存储
kibana	多种图标配置简单	仅⽀持es	展示，分析
grafana	多数据源⽀持，⾃带警报	偏监控⽅向	分析，预警

一、SLF4J ​

1.1 简单使用 ​

添加依赖 ​

使用demo ​

1.2 与其他日志框架整合 ​

1.3 桥接新的日志框架 ​

二、JUL ​

2.1 日志配置 ​

日志级别 ​

父子关系 ​

2.2 配置文件 ​

读取配置文件 ​

配置文件 ​

原理分析 ​

三、Log4J ​

3.1 日志级别介绍 ​

3.2 使用Demo ​

添加依赖 ​

日志记录 ​

3.3 组件介绍 ​

Loggers ​

Appenders ​

Layouts ​

3.4 拓展 ​

Layout格式 ​

Appender的输出配置 ​

properties方式 ​

xml方式 ​

四、log4j2 ​

4.1 使用Demo ​

依赖 ​

日志记录 ​

4.2 slf4j集成log4j2 ​

依赖 ​

配置 ​

4.3 日志处理器 ​

4.4 日志格式化 ​

4.5 异步日志 ​

添加依赖 ​

AsyncAppender方式 ​

AsyncLogger方式 ​

4.6 无垃圾记录 ​

五、Logback ​

5.1 使用demo ​

依赖 ​

日志记录 ​

配置读取说明 ​

配置文件 ​

使用Spring配置 ​

5.2 logback-access的使用 ​

六、SpringBoot日志使用 ​

6.1 使用Demo ​

依赖 ​

记录日志 ​

配置 ​

6.2 指定配置文件 ​

6.3 使用SpringBoot解析日志配置 ​

6.4 将日志切换为log4j2 ​

七、日志中间件 ​

一、SLF4J

1.1 简单使用

添加依赖

使用demo

1.2 与其他日志框架整合

1.3 桥接新的日志框架

二、JUL

2.1 日志配置

日志级别

父子关系

2.2 配置文件

读取配置文件

配置文件

原理分析

三、Log4J

3.1 日志级别介绍

3.2 使用Demo

添加依赖

日志记录

3.3 组件介绍

Loggers

Appenders

Layouts

3.4 拓展

Layout格式

Appender的输出配置

properties方式

xml方式

四、log4j2

4.1 使用Demo

依赖

日志记录

4.2 slf4j集成log4j2

依赖

配置

4.3 日志处理器

4.4 日志格式化

4.5 异步日志

添加依赖

AsyncAppender方式

AsyncLogger方式

4.6 无垃圾记录

五、Logback

5.1 使用demo

依赖

日志记录

配置读取说明

配置文件

使用Spring配置

5.2 logback-access的使用

六、SpringBoot日志使用

6.1 使用Demo

依赖

记录日志

配置

6.2 指定配置文件

6.3 使用SpringBoot解析日志配置

6.4 将日志切换为log4j2

七、日志中间件